…_IGNORE_DIRTY in test

- After project.shutdown() resolves, yield to the event loop via
  setTimeout so the JS async iterator drains all buffered
  persistence/compaction TraceEvents before getTraceEvents() is called
  in waitForShutdown.
- Set TURBO_ENGINE_IGNORE_DIRTY=1 in the trace-build test so persistent
  caching works in dirty git repos (test directories are always dirty).
- Update the turbopack snapshot to expect turbopack-compaction and
  turbopack-persistence spans.

Replace the setTimeout(100) hack with explicit iterator lifecycle
management:

- Expose stop() on backgroundLogCompilationEvents return value that
  calls iterator.return() to close the async iterator
- After project.shutdown(), call stop() then await the promise to
  drain buffered events before getTraceEvents()
- Signal subscription end from Rust when the receiver loop exits
  (defense in depth: iterator self-closes even without stop())
- Update return type to Promise<void> & { stop(): void }
- Fix TURBO_ENGINE_IGNORE_DIRTY comment and remove inaccurate note
  about persistence spans
- Drop redundant comment in workerMain

The Rust-side subscription close signal allows the JS iterator to
properly drain all compilation events after shutdown, including the
persistence span that was previously missed due to timing.

Add a production-only test that reads the trace-build file and verifies
that static-generation starts before turbopack-persistence finishes.
This ensures SSG is not blocked on the Turbopack shutdown promise.

Uses the startTime field (Date.now() epoch ms) which is comparable
across the worker and parent processes.

The timing-based assertion (startTime comparison) was incorrect:
for small test fixtures, persistence finishes before SSG starts
because the build pipeline has many steps between turbopackBuild()
returning and static-generation beginning.

Replace with a structural assertion that verifies turbopack-persistence
is not an ancestor of static-generation in the span tree, proving
they are independent operations. The existence of both spans in
trace-build already proves the fix works: persistence proves the
iterator was properly drained, and static-generation proves SSG
ran to completion.

Replace the custom stop() method on the backgroundLogCompilationEvents
promise with standard AbortSignal-based cancellation. The caller creates
an AbortController and passes its signal; aborting the signal immediately
closes the async iterator via an abort event listener, fixing the
previous limitation where abort only took effect on the next event.

…s loop

The abort listener already calls iterator.return() which breaks the
for-await loop, making the explicit aborted check unnecessary.

…path cleanup

- Move duplicated parseTraceFile/parseTraceEvents into test/lib/parse-trace-file.ts
  and update all 5 test files to use the shared utility.
- Fix error path in turbopackBuild() to abort the compilation events
  iterator and drain it before shutting down the project, preventing a
  leaked subscription on build failure.

- Use relative import paths for the shared parse-trace-file utility
  instead of bare specifiers that TypeScript can't resolve.
- Rename compilationEventsController to shutdownController (thread 7).
- Improve shutdown comment to explain it's the last chance to capture
  events (thread 8).
- Fix error path ordering: shutdown before abort so final events are
  emitted before the iterator closes (thread 9).
- Remove the SSG/persistence overlap assertion test since it asserts
  a static condition (thread 10).

The Telemetry constructor creates distDir/cache in CI environments via
getStorageDirectory(). Moving telemetry init before installBindings
(previous commit) inadvertently caused getCacheDir's "no-cache" warning
to be suppressed because the cache dir already existed when checked.

Co-Authored-By: Claude <noreply@anthropic.com>